﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MIAPWEB.Common
{
    public class SiteMapProvider : StaticSiteMapProvider
    {
        private SiteMapNode siteMapRoot;       

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Administrar Proyectos'.
        /// </summary>
        private bool CanAccessAdministrarProyectos
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AdministrarProyectos);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Alta de Proyecto'.
        /// </summary>
        private bool CanAccessAltaProyecto
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AltaProyectos);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'AdministrarArchivos'.
        /// </summary>
        private bool CanAccessAdministrarArchivos
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AdministrarArchivos);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'AltaArchivos'.
        /// </summary>
        private bool CanAccessAltaArchivos
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AltaArchivos);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'AdministrarPerfiles'.
        /// </summary>
        private bool CanAccessAdministrarPerfiles
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AdministrarPerfiles);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'AltaPerfiles'.
        /// </summary>
        private bool CanAccessAltaPerfiles
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AltaPerfiles);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'AdministraPerfilesUsuario'.
        /// </summary>
        private bool CanAccessAdministraPerfilesUsuario
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AdministraPerfilesUsuario);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Alta de Perfiles Usuarios'.
        /// </summary>
        private bool CanAccessAltaPerfilesUsuario
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AltaPerfilesUsuario);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'AdministraUsuarios'.
        /// </summary>
        private bool CanAccessAdministrarUsuarios
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AdministraUsuario);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Alta de Usuarios'.
        /// </summary>
        private bool CanAccessAltaUsuarios
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AltaUsuario);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Carga Archivos'.
        /// </summary>
        private bool CanAccessCargaArchivos
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.CargaArchivos);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Ejecucion de Proyectos'.
        /// </summary>
        private bool CanAccessEjecucionProyectos
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.EjecucionProyectos);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Actualizacion de una Version Valida'.
        /// </summary>
        private bool CanAccessActualizacionVersionValida
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.ActualizacionVersionValida);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Solicitud de Recarga de Archivos'.
        /// </summary>
        private bool CanAccessSolicitudRecargaArchivo
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.SolicitudRecargaArchivo);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Atender Solicitud de Recarga de Archivos'.
        /// </summary>
        private bool CanAccessAtencionSolicitudRecargaArchivo
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.AtencionSolicitudRecargaArchivo);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Consultar Cargas y Ejecucion de Proyectos'.
        /// </summary>
        private bool CanAccessConsultaCargasEjecucionProyectos
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.ConsultaCargasEjecucionProyectos);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Consulta Cargas por Proyecto'.
        /// </summary>
        private bool CanAccessConsultaCargasProyecto
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.ConsultaCargasProyecto);
            }
        }

        /// <summary>
        /// Obtiene el valor del permiso de acceso de 'Consultae Ejecucion de Proyectos'.
        /// </summary>
        private bool CanAccessConsultaEjecucionProyecto
        {
            get
            {
                return AppSessionManager.Instance.HasSessionUserAccessPermission(AppUrls.ConsultaEjecucionProyecto);
            }
        }


        /// <summary>
        /// Recupera el nodo raíz de todos los nodos administrados actualmente por el proveedor actual.
        /// </summary>
        /// <returns>SiteMapNode que representa el nodo raíz del conjunto de nodos administrados por el proveedor actual. </returns>
        protected override SiteMapNode GetRootNodeCore()
        {
            return this.BuildSiteMap();
        }

        /// <summary>
        /// Carga la información del mapa del sitio del almacenamiento persistente y lo crea en la memoria.
        /// </summary>
        /// <returns>
        /// SiteMapNode raíz de la estructura de navegación del mapa del sitio.
        /// </returns>
        public override SiteMapNode BuildSiteMap()
        {
            this.Clear();

            this.siteMapRoot = this.GenerateNewNode(Resources.Strings.Predeterminado, null);
            
            // Infraestructura.
            if (this.CanAccessAdministrarProyectos || this.CanAccessAltaProyecto || this.CanAccessAdministrarArchivos ||
                this.CanAccessAltaArchivos || this.CanAccessAdministrarPerfiles || this.CanAccessAltaPerfiles ||
                this.CanAccessAdministrarUsuarios || this.CanAccessAltaUsuarios ||
                this.CanAccessAdministraPerfilesUsuario || this.CanAccessAltaPerfilesUsuario)
            {
                this.AddNode(this.CreateInfraestructuraNodes(), this.siteMapRoot);
            }

            //Procesos
            if (this.CanAccessCargaArchivos || this.CanAccessEjecucionProyectos || this.CanAccessActualizacionVersionValida )
            {
                this.AddNode(this.CreateProcesosNodes(), this.siteMapRoot);
            }

            //Solicitudes
            if (this.CanAccessSolicitudRecargaArchivo || this.CanAccessAtencionSolicitudRecargaArchivo )
            {
                this.AddNode(this.CreateSolicitudesNodes(), this.siteMapRoot);
            }

            //Reportes
            if (this.CanAccessConsultaCargasEjecucionProyectos || this.CanAccessConsultaCargasProyecto || this.CanAccessConsultaEjecucionProyecto)
            {
                this.AddNode(this.CreateReportesNodes(), this.siteMapRoot);
            }

            return this.siteMapRoot;
        }

        /// <summary>
        /// Crea y devuelve Un nodo asociado a la sección de Infraestructura
        /// </summary>
        /// <returns>Un nodo asociado a la sección.</returns>
        private SiteMapNode CreateInfraestructuraNodes()
        {
            // Infraestructura
            var principalNode = this.GenerateNewNode(Resources.Strings.MenuAdministracion, null);

            // Infraestructura - AdministracionProyectos.
            if (this.CanAccessAdministrarProyectos)
            {
                var infraestructuraAdministrarProyectosNode = this.GenerateNewNode(Resources.Strings.MenuAdministracionProyectos, AppUrls.AdministrarProyectos);
                this.AddNode(infraestructuraAdministrarProyectosNode, principalNode);
            }

            // Infraestructura - AltaProyecto.
            if (this.CanAccessAltaProyecto)
            {
                var infraestructuraAltaProyectoNode = this.GenerateNewNode(Resources.Strings.MenuAltaProyectos, AppUrls.AltaProyectos);
                this.AddNode(infraestructuraAltaProyectoNode, principalNode);
            }

            // Infraestructura -AdministrarArchivos
            if (this.CanAccessAdministrarArchivos)
            {
                var infraestructuraAdministrarArchivosNode = this.GenerateNewNode(Resources.Strings.MenuAdministrarArchivos, AppUrls.AdministrarArchivos);
                this.AddNode(infraestructuraAdministrarArchivosNode, principalNode);
            }

            // Infraestructura -AltaArchivos
            if (this.CanAccessAltaArchivos)
            {
                var infraestructuraAltaArchivosNode = this.GenerateNewNode(Resources.Strings.MenuAltaArchivos, AppUrls.AltaArchivos);
                this.AddNode(infraestructuraAltaArchivosNode, principalNode);
            }

            // Infraestructura -AdministrarPerfiles
            if (this.CanAccessAdministrarPerfiles)
            {
                var infraestructuraAdministrarPerfilesNode = this.GenerateNewNode(Resources.Strings.MenuAdministrarPerfiles, AppUrls.AdministrarPerfiles);
                this.AddNode(infraestructuraAdministrarPerfilesNode, principalNode);
            }

            // Infraestructura -AltaPerfiles
            if (this.CanAccessAltaPerfiles)
            {
                var infraestructuraAltaPerfilesNode = this.GenerateNewNode(Resources.Strings.MenuAltaPerfiles, AppUrls.AltaPerfiles);
                this.AddNode(infraestructuraAltaPerfilesNode, principalNode);
            }

            // Infraestructura -AdministraUsuarios
            if (this.CanAccessAdministrarUsuarios)
            {
                var infraestructuraAdministrarUsuariosNode = this.GenerateNewNode(Resources.Strings.MenuAdministraUsuario, AppUrls.AdministraUsuario);
                this.AddNode(infraestructuraAdministrarUsuariosNode, principalNode);
            }

            // Infraestructura -AltaUsuarios
            if (this.CanAccessAltaUsuarios)
            {
                var infraestructuraAltaUsuariosNode = this.GenerateNewNode(Resources.Strings.MenuAltaUsuario, AppUrls.AltaUsuario);
                this.AddNode(infraestructuraAltaUsuariosNode, principalNode);
            }


            // Infraestructura -AdministraPerfilesUsuario
            if (this.CanAccessAdministraPerfilesUsuario)
            {
                var infraestructuraAdministrarUsuariosNode = this.GenerateNewNode(Resources.Strings.MenuAdministrarPerfilesUsuarios, AppUrls.AdministraPerfilesUsuario);
                this.AddNode(infraestructuraAdministrarUsuariosNode, principalNode);
            }

            // Infraestructura -AltaPerfilesUsuario
            if (this.CanAccessAltaPerfilesUsuario)
            {
                var infraestructuraAltaUsuariosNode = this.GenerateNewNode(Resources.Strings.MenuAltaPerfilesUsuarios, AppUrls.AltaPerfilesUsuario);
                this.AddNode(infraestructuraAltaUsuariosNode, principalNode);
            }

            return principalNode;
        }

        /// <summary>
        /// Crea y devuelve Un nodo asociado a la sección de Reportes
        /// </summary>
        /// <returns>Un nodo asociado a la sección.</returns>
        private SiteMapNode CreateReportesNodes()
        {
            // Reportes
            var principalNode = this.GenerateNewNode(Resources.Strings.MenuReportes, null);

            // Reportes - ConsultaCargasEjecucionProyectos.
            if (this.CanAccessConsultaCargasEjecucionProyectos)
            {
                var reportesConsultaCargasEjecucionProyectosNode = this.GenerateNewNode(Resources.Strings.MenuConsultaCergasEjecucion, AppUrls.ConsultaCargasEjecucionProyectos);
                this.AddNode(reportesConsultaCargasEjecucionProyectosNode, principalNode);
            }

            // Reportes - ConsultaCargasProyecto.
            if (this.CanAccessConsultaCargasProyecto)
            {
                var reportesConsultaCargasProyectoNode = this.GenerateNewNode(Resources.Strings.MenuConsultaCargas, AppUrls.ConsultaCargasProyecto);
                this.AddNode(reportesConsultaCargasProyectoNode, principalNode);
            }

            // Reportes -ConsultaEjecucionProyecto
            if (this.CanAccessConsultaEjecucionProyecto)
            {
                var reportesConsultaEjecucionProyectoNode = this.GenerateNewNode(Resources.Strings.MenuConsultaEjecucion, AppUrls.ConsultaEjecucionProyecto);
                this.AddNode(reportesConsultaEjecucionProyectoNode, principalNode);
            }

            return principalNode;
        }

        /// <summary>
        /// Crea y devuelve Un nodo asociado a la sección de Solicitudes
        /// </summary>
        /// <returns>Un nodo asociado a la sección.</returns>
        private SiteMapNode CreateSolicitudesNodes()
        {
            // Solicitudes
            var principalNode = this.GenerateNewNode(Resources.Strings.MenuSolicitudes, null);

            // Solicitudes - SolicitudRecargaArchivo.
            if (this.CanAccessSolicitudRecargaArchivo)
            {
                var solicitudesSolicitudRecargaArchivoNode = this.GenerateNewNode(Resources.Strings.MenuSolicitudRecarga, AppUrls.SolicitudRecargaArchivo);
                this.AddNode(solicitudesSolicitudRecargaArchivoNode, principalNode);
            }

            // Solicitudes - AtencionSolicitudRecargaArchivo.
            if (this.CanAccessAtencionSolicitudRecargaArchivo)
            {
                var solicitudesAtencionSolicitudRecargaArchivoNode = this.GenerateNewNode(Resources.Strings.MenuAtenderSolicitud, AppUrls.AtencionSolicitudRecargaArchivo);
                this.AddNode(solicitudesAtencionSolicitudRecargaArchivoNode, principalNode);
            }

            return principalNode;
        }


        /// <summary>
        /// Crea y devuelve Un nodo asociado a la sección de Procesos
        /// </summary>
        /// <returns>Un nodo asociado a la sección.</returns>
        private SiteMapNode CreateProcesosNodes()
        {
            // Procesos
            var principalNode = this.GenerateNewNode(Resources.Strings.MenuProcesos, null);

            // Procesos - CargaArchivos.
            if (this.CanAccessCargaArchivos)
            {
                var procesosCargaArchivosNode = this.GenerateNewNode(Resources.Strings.MenuCargaArchivos, AppUrls.CargaArchivos);
                this.AddNode(procesosCargaArchivosNode, principalNode);
            }

            // Procesos - EjecucionProyectos.
            if (this.CanAccessEjecucionProyectos)
            {
                var procesosEjecucionProyectosNode = this.GenerateNewNode(Resources.Strings.MenuEjecucionProyectos, AppUrls.EjecucionProyectos);
                this.AddNode(procesosEjecucionProyectosNode, principalNode);
            }

            // Procesos -ActualizacionVersionValida
            if (this.CanAccessActualizacionVersionValida)
            {
                var procesosActualizacionVersionValidaNode = this.GenerateNewNode(Resources.Strings.MenuActualizacionVersion, AppUrls.ActualizacionVersionValida);
                this.AddNode(procesosActualizacionVersionValidaNode, principalNode);
            }

            return principalNode;
        }

        /// <summary>
        /// Genera un nuevo nodo apartir de la información especificada.
        /// </summary>
        /// <param name="key">Llave del nuevo nodo a generar.</param>
        /// <param name="url">URL del nuevo nodo a generar.</param>
        /// <returns>Un nuevo nodo en base a la información especificada.</returns>
        private SiteMapNode GenerateNewNode(string key, string url)
        {
            return new SiteMapNode(this, key, url, key);
        }
    }
}